/**
 * 认证相关工具函数
 */
import { getCache, setCache, removeCache, CACHE_KEYS } from '@/utils/cache';

/**
 * 用户信息接口
 */
export interface UserInfo {
  id: string | number;
  username: string;
  nickname?: string;
  avatar?: string;
  email?: string;
  phone?: string;
  role?: string;
  permissions?: string[];
  lastLoginTime?: string;
}

/**
 * 登录响应接口
 */
export interface LoginResponse {
  token: string;
  refreshToken?: string;
  userInfo: UserInfo;
  expiresIn?: number;
}

/**
 * Token管理类
 */
export class TokenManager {
  /**
   * 设置token
   * @param token JWT token
   * @param expiresIn 过期时间（秒），默认7天
   */
  static setToken(token: string, expiresIn: number = 7 * 24 * 60 * 60): void {
    setCache(CACHE_KEYS.TOKEN, token, expiresIn);
    console.log('🔐 Token已保存:', token.substring(0, 20) + '...');
  }

  /**
   * 获取token
   * @returns token字符串或null
   */
  static getToken(): string | null {
    const token = getCache(CACHE_KEYS.TOKEN);
    return token;
  }

  /**
   * 移除token
   */
  static removeToken(): void {
    removeCache(CACHE_KEYS.TOKEN);
    console.log('🗑️ Token已清除');
  }

  /**
   * 检查token是否存在
   * @returns boolean
   */
  static hasToken(): boolean {
    return !!this.getToken();
  }

  /**
   * 检查token是否有效（简单检查格式）
   * @returns boolean
   */
  static isValidToken(): boolean {
    const token = this.getToken();
    if (!token) return false;
    
    // 简单的JWT格式检查
    const parts = token.split('.');
    return parts.length === 3;
  }

  /**
   * 解析token payload（不验证签名）
   * @returns payload对象或null
   */
  static parseTokenPayload(): any {
    const token = this.getToken();
    if (!token) return null;
    
    try {
      const parts = token.split('.');
      if (parts.length !== 3) return null;
      
      const payload = JSON.parse(atob(parts[1]));
      return payload;
    } catch (error) {
      console.error('解析token失败:', error);
      return null;
    }
  }

  /**
   * 检查token是否即将过期（30分钟内）
   * @returns boolean
   */
  static isTokenExpiringSoon(): boolean {
    const payload = this.parseTokenPayload();
    if (!payload || !payload.exp) return false;
    
    const expirationTime = payload.exp * 1000; // 转换为毫秒
    const currentTime = Date.now();
    const thirtyMinutes = 30 * 60 * 1000;
    
    return (expirationTime - currentTime) < thirtyMinutes;
  }
}

/**
 * 用户信息管理类
 */
export class UserManager {
  /**
   * 设置用户信息
   * @param userInfo 用户信息对象
   */
  static setUserInfo(userInfo: UserInfo): void {
    setCache(CACHE_KEYS.USER_INFO, userInfo);
    console.log('👤 用户信息已保存:', userInfo.username);
  }

  /**
   * 获取用户信息
   * @returns 用户信息对象或null
   */
  static getUserInfo(): UserInfo | null {
    return getCache(CACHE_KEYS.USER_INFO);
  }

  /**
   * 移除用户信息
   */
  static removeUserInfo(): void {
    removeCache(CACHE_KEYS.USER_INFO);
    console.log('🗑️ 用户信息已清除');
  }

  /**
   * 检查用户是否已登录
   * @returns boolean
   */
  static isLoggedIn(): boolean {
    return TokenManager.hasToken() && !!this.getUserInfo();
  }

  /**
   * 检查用户是否有特定权限
   * @param permission 权限字符串
   * @returns boolean
   */
  static hasPermission(permission: string): boolean {
    const userInfo = this.getUserInfo();
    if (!userInfo || !userInfo.permissions) return false;
    
    return userInfo.permissions.includes(permission);
  }

  /**
   * 检查用户是否有特定角色
   * @param role 角色字符串
   * @returns boolean
   */
  static hasRole(role: string): boolean {
    const userInfo = this.getUserInfo();
    return userInfo?.role === role;
  }
}

/**
 * 认证工具类
 */
export class AuthUtils {
  /**
   * 登录成功后的处理
   * @param loginResponse 登录响应数据
   */
  static handleLoginSuccess(loginResponse: LoginResponse): void {
    const { token, userInfo, expiresIn } = loginResponse;
    
    // 保存token
    TokenManager.setToken(token, expiresIn);
    
    // 保存用户信息
    UserManager.setUserInfo(userInfo);
    
    console.log('✅ 登录成功，用户信息已保存');
  }

  /**
   * 登出处理
   */
  static handleLogout(): void {
    // 清除token和用户信息
    TokenManager.removeToken();
    UserManager.removeUserInfo();
    
    console.log('👋 用户已登出');
  }

  /**
   * 检查认证状态
   * @returns boolean
   */
  static isAuthenticated(): boolean {
    return TokenManager.hasToken() && TokenManager.isValidToken() && UserManager.isLoggedIn();
  }

  /**
   * 获取认证头
   * @returns Authorization header值或null
   */
  static getAuthHeader(): string | null {
    const token = TokenManager.getToken();
    return token ? `Bearer ${token}` : null;
  }
}

// 导出常用方法
export const {
  setToken,
  getToken,
  removeToken,
  hasToken,
  isValidToken,
  parseTokenPayload,
  isTokenExpiringSoon
} = TokenManager;

export const {
  setUserInfo,
  getUserInfo,
  removeUserInfo,
  isLoggedIn,
  hasPermission,
  hasRole
} = UserManager;

export const {
  handleLoginSuccess,
  handleLogout,
  isAuthenticated,
  getAuthHeader
} = AuthUtils;
